package com.designPattern.interfaceSegregationPrinciple;

/**
 * @author zsj
 * @date 2023/5/11 17:04
 */
public class InterfaceSegregationFuckIngUp {

    public static void main(String[] args) {
        A a = new A();
        a.depend1(new B());
        a.depend2(new B());
        a.depend3(new B());
        C c = new C();
        c.depend1(new D());
        c.depend4(new D());
        c.depend5(new D());
    }
}


/**
 * 遵循接口隔离原则  就需要把接口拆分为几个接口 不同类使用的接口功能不同 作为几个即可写出来即可
 * 使这些类不在需要重写 自己不需要的功能方法
 */
interface Interface_one {
    void f1();
}


interface Interface_two {


    void f2();

    void f3();
}

interface Interface_three {

    void f4();

    void f5();
}


class B implements Interface_one, Interface_two {
    @Override
    public void f1() {
        System.out.println("B 实现了 f1");
    }

    @Override
    public void f2() {
        System.out.println("B 实现了 f2");
    }

    @Override
    public void f3() {
        System.out.println("B 实现了 f3");
    }
}


class D implements Interface_one, Interface_three {


    @Override
    public void f1() {
        System.out.println("D 实现了 f1");
    }

    @Override
    public void f4() {

        System.out.println("D 实现了 f4");
    }

    @Override
    public void f5() {

        System.out.println("D 实现了 f5");
    }
}


class A {
    //A  类通过接口Interface_one 依赖使用 B类 但是只会使用到1，2，3
    public void depend1(Interface_one i) {
        i.f1();
    }

    public void depend2(Interface_two i) {
        i.f2();
    }

    public void depend3(Interface_two i) {
        i.f3();
    }
}

class C {
    //C类只使用到了145 方法
    public void depend1(Interface_one i) {
        i.f1();
    }

    public void depend4(Interface_three i) {
        i.f4();
    }

    public void depend5(Interface_three i) {
        i.f5();
    }
}